﻿using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace Calculalouca
{
    class GerenciadorMatriz
    {
        Random random = new Random();

        public GerenciadorMatriz()
        {
            int valorMin = -50;
            int valorMax = 100;
        }
        //public float[,] GerarMatriz(int numLine, int numColuns, int numeroMaximo, int NumeroMinimo)
        //{
        //    float[,] geradora = new float[numLine, numColuns];

        //    for (int i = 0; i < numLine; i++)
        //    {
        //        for (int j = 0; j < numColuns; j++)
        //        {
        //            geradora[i, j] = NumeroMinimo + random.Next(numeroMaximo - NumeroMinimo);
        //        }
        //    }

        //    return geradora;
        //}
        public static Matriz SomarMatrizes(Matriz matrizA, Matriz matrizB)
        {
            Matriz resultado = new Matriz(matrizA.nLines, matrizA.nColumns);

            for (int i = 0; i < matrizA.nLines; i++)
            {
                for (int j = 0; j < matrizA.nColumns; j++)
                {
                    resultado.valoresMatriz[i, j] = (matrizA.valoresMatriz[i, j] + matrizB.valoresMatriz[i, j]);
                }
            }
            return resultado;
        }
        public static Matriz SubatrairMatrizes(Matriz matrizA, Matriz matrizB)
        {
            Matriz resultado = new Matriz(matrizA.nLines, matrizA.nColumns);

            for (int i = 0; i < matrizA.nLines; i++)
            {
                for (int j = 0; j < matrizA.nColumns; j++)
                {
                    resultado.valoresMatriz[i, j] = matrizA.valoresMatriz[i, j] - matrizB.valoresMatriz[i, j];
                }
            }
            return resultado;
        }
        public static Matriz MultiplicarMatrizesPorMatrizes(Matriz matrizA, Matriz matrizB)
        {
            Matriz resultado = new Matriz(matrizA.nLines, matrizB.nColumns);

            if (matrizA.nLines == matrizB.nColumns)
            {
                for (int i = 0; i < resultado.nLines; i++)
                {
                    for (int j = 0; j < resultado.nColumns; j++)
                    {
                        float count = 0;

                        for (int l = 0; l < resultado.nLines; l++)
                        {
                            count += matrizA.valoresMatriz[i, l] * matrizB.valoresMatriz[l, j];
                        }
                        resultado.valoresMatriz[i, j] = count;
                    }
                }
            }
            return resultado;
        }

        public static Matriz MultiplicarMatrizesNumeral(Matriz matrizA, float numeral)
        {
            Matriz resultado = new Matriz(matrizA.nLines, matrizA.nColumns);

            for (int i = 0; i < resultado.nLines; i++)
            {
                for (int j = 0; j < resultado.nColumns; j++)
                {
                    resultado.valoresMatriz[i, j] = numeral * matrizA.valoresMatriz[i, j];
                }
            }
            return resultado;

        }

        public static Matriz OpostaMatrix(Matriz matrizA)
        {
            Matriz resultado = matrizA;

            for (int i = 0; i < resultado.nLines; i++)
            {
                for (int j = 0; j < resultado.nColumns; j++)
                {
                    resultado.valoresMatriz[i, j] *= -1;
                }
            }
            return resultado;
        }
        public static Matriz TranspostaMatrizes(Matriz matrizA)
        {
            Matriz resultado = new Matriz(matrizA.nLines, matrizA.nColumns);

            for (int i = 0; i < matrizA.nLines; i++)
            {
                for (int j = 0; j < matrizA.nColumns; j++)
                {
                    resultado.valoresMatriz[i, j] = matrizA.valoresMatriz[j, i];
                }
            }
            return resultado;
        }

        public static float DeterminanteMatrizes(Matriz matrizA)
        {
            float resultado = 0;

            float countA = 1;
            float countB = 1;

            for (int i = 0; i < matrizA.nLines; i++)
            {
                for (int j = 0; j < matrizA.nColumns; j++)
                {
                    if (i == j)
                    {
                        countA *= matrizA.valoresMatriz[i, j];
                    }
                    else
                    {
                        countB *= matrizA.valoresMatriz[i, j];
                    }
                }
            }
            return countA - countB;
        }
    }
}